package co.wangdao.xingshaoye.utils;

import android.content.Context;
import android.widget.TextView;
import android.widget.Toast;

import java.math.BigDecimal;
import java.text.DateFormat;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;

public class StringUtils {
    /**
     * 字符串截取
     */
    public static String subString(String value, int maxLen) {
        if (isEmpty(value)) {
            return "";
        }
        if (value.length() > maxLen) {
            return value.substring(0, maxLen) + "...";
        }
        return value;
    }

    /**
     * 字符长度验证
     *
     * @param value     字符串
     * @param errorStr  错误提示
     * @param head_text
     * @param context   上下文
     * @param minLength 最小长度. 不填或填0 均表示不验证最小长度
     * @return
     */
    public static boolean Validata(String value, String errorStr, String head_text, Context context, int... minLength) {
        if (isEmpty(value)) {
            ToastUtil.showToast(context, errorStr);
            return false;
        }
        if (minLength[0] != 0 && value.length() < minLength[0]) {
            ToastUtil.showToast(context, head_text + "长度至少" + minLength[0] + "位");
            return false;
        }
        if (minLength.length > 1) {
            if (minLength[1] != 0 && value.length() > minLength[1]) {
                ToastUtil.showToast(context, head_text + "长度不能超过" + minLength[1] + "位");
                return false;
            }
        }
        return true;
    }

    /**
     * 检查字符串是否为空
     */
    public static boolean isEmpty(String value) {
        if (value == null || value.length() == 0) {
            return true;
        } else if (Regular.IsEmpty(value)) {
            return true;
        }
        return false;
    }

    public static boolean isEmpty(Object obj) {
        return isEmpty((String) obj);
    }

    /**
     * 去除首尾空格
     */
    public static String trim(String text) {
        return trim(text, ' ');
    }

    /**
     * 去除首尾字符
     *
     * @param text 初始值
     * @param Reg  要匹配的字符数组集合
     * @return
     */
    public static String trim(String text, Character... Reg) {
        if (isEmpty(text))
            return "";
        if (Reg.length == 1 && Reg[0] == ' ')
            return text.trim();

        int start, offset, last = text.length() - 1;
        start = offset = 0;
        char[] value = text.toCharArray();
        int end = last;
        ArrayList<Character> arrayList = new ArrayList<Character>(Arrays.asList(Reg));
        while ((start <= end) && arrayList.contains(value[start])) {
            start++;
        }
        while ((end >= start) && arrayList.contains(value[end])) {
            end--;
        }
        if (start == offset && end == last) {
            return text;
        }
        return text.substring(start, end - start + 1);
    }

    /**
     * 转换成字符串
     *
     * @param obj 要转换的值
     * @param t   绑定的控件
     * @return 转换后的值
     */
    public static <T extends TextView> String toString(Object obj, T t) {
        return toString(obj, t, "");
    }

    /**
     * 转换成字符串
     *
     * @param obj          要转换的值
     * @param t            绑定的控件
     * @param defaultValue “空值”时默认的返回值
     * @return 转换后的值
     */
    public static <T extends TextView> String toString(Object obj, T t, String defaultValue) {
        String text = toString(obj, defaultValue);
        if (!text.equals(defaultValue)) {
            t.setText(text);
        }
        return text;
    }

    /**
     * 转换成字符串
     *
     * @param obj 要转换的值
     * @return
     */
    public static String toString(Object obj) {
        return toString(obj, "");
    }

    /**
     * 转换成字符串
     *
     * @param obj          要转换的值
     * @param defaultValue 转换失败时返回的默认值
     * @return
     */
    public static String toString(Object obj, String defaultValue) {
        return toString(obj, defaultValue, "");
    }

    public static String toString(int obj) {
        return toString(obj, "");
    }

    /**
     * 过滤对比值
     *
     * @param obj          要转换的值
     * @param defaultValue 默认值
     * @param equalsValue  对比值
     * @return
     */
    public static String toString(Object obj, String defaultValue, String equalsValue) {
        if (obj == null) {
            return defaultValue;
        }
        String str = obj.toString();
        if (isEmpty(str)) {
            return defaultValue;
        }
        if (str.equals(equalsValue))
            return defaultValue;
        return str;
    }

    /**
     * 将单精度浮点型转为字符串类型，保留小数点后两位(不足时以0补充)
     *
     * @param value
     * @param isDecimal 暂时没有用处，仅用于区分另一个toString方法
     * @return
     */
    public static String toString(Object value, int isDecimal) {
        return toString(value, "##0.00", isDecimal);
    }

    /**
     * 将单精度浮点型转为字符串类型，保留小数点后两位(不足时以0补充)
     *
     * @param value
     * @param pattern   可自定义格式化规则
     * @param isDecimal 暂时没有用处，仅用于区分另一个toString方法
     * @return
     */
    public static String toString(Object value, String pattern, int isDecimal) {
        if (value == null) {
            return "0.00";
        }
        DecimalFormat decimalFormat = new DecimalFormat(pattern);// 构造方法的字符格式这里如果小数不足2位,会以0补足.
        if (value instanceof String) {
            String v = (String) value;
            if (v.equals("0") || v.equals("null") || v.equals("0.0")) {
                return "0.00";
            }
            float result = Float.parseFloat(v);
            return decimalFormat.format(result);
        }
        return decimalFormat.format(value);// format 返回的是字符串
    }

    /**
     * 将浮点型转换为保留两位小数的字符串
     *
     * @param d 要转换的值
     * @return 保留两位小数的字符串
     */
    public static String toString(double d) {
        DecimalFormat df = new DecimalFormat("######0.00");
        return df.format(d);
    }

    //把金额转成 123,123.00格式
    public static String parseMoney(String value) {
        BigDecimal bigDecimal = new BigDecimal(value);
        DecimalFormat df = new DecimalFormat(",###,##0.00");
        return df.format(bigDecimal);
    }

    /**
     * 手机号码有效性验证
     *
     * @param phoneNumber 手机号码
     * @param context
     * @return
     */
    public static boolean judgmentPhoneNumber(String phoneNumber, Context context) {

        if (isEmpty(phoneNumber)) {
            Toast.makeText(context, "请输入手机号!", Toast.LENGTH_SHORT).show();
            return false;
        } else if (phoneNumber.length() != 11) {
            Toast.makeText(context, "请正确输入手机号码", Toast.LENGTH_SHORT).show();
            return false;
        } else {
            return true;
            // boolean b_1 = Regular.IsVaildPhone(phoneNumber);
            // if (!b_1) {
            // Toast.makeText(context, "无效的手机号码!", Toast.LENGTH_LONG).show();
            // return false;
            // } else {
            // return true;
            // }
        }
    }

    /**
     * 验证用户密码一致性
     *
     * @param psw        密码
     * @param confirmPSW 确认密码
     * @param context
     * @return
     */
    public static boolean judgmentPassword(String psw, String confirmPSW, Context context) {
        if (!Validata(psw, "请输入密码", "密码", context, 6, 20)) {
            return false;
        }
        if (!Validata(confirmPSW, "请输入确认密码", "确认密码", context, 6, 20)) {
            return false;
        }
        if (!psw.equals(confirmPSW)) {
            Toast.makeText(context, "两次密码不一致，请重新输入", Toast.LENGTH_SHORT).show();
            return false;
        }
        return true;
    }

    /**
     * 显示的时间转换 // 设置未付款交易的超时时间 // 默认30分钟，一旦超时，该笔交易就会自动被关闭。 // 取值范围：1m～15d。 //
     * m-分钟，h-小时，d-天，1c-当天（无论交易何时创建，都在0点关闭）。 // 该参数数值不接受小数点，如1.5h，可转换为90m。
     */
    public static String TimeConvert(String time) {
        LogUtil.d("time: " + time);
        if (isEmpty(time) || time.length() == 0) {
            return "";
        }
        char type = time.charAt(time.length() - 1);
        long t = Long.parseLong(time.substring(0, time.length() - 1));
        // 以服务器时间为准
        long currentTime = System.currentTimeMillis();
        switch (type) {
            case 'm': // 分钟 *60*1000
                currentTime += t * 60 * 1000;
                break;
            case 'h': // 小时 *60 *60*1000
                currentTime += t * 60 * 60 * 1000;
                break;
            case 'd': // 天 *24*60 *60*1000
                currentTime += t * 24 * 60 * 60 * 1000;
                break;
            case 'c': // 当天（无论交易何时创建，都在0点关闭）。
                // TODO 计算

                break;
        }
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return format.format(currentTime);
    }

    /**
     * 计算两个日期之间相差的天数
     *
     * @param smdate 较小的时间
     * @param bdate  较大的时间
     * @return 相差天数
     */
    public static int daysBetween(Date smdate, Date bdate) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        try {
            smdate = sdf.parse(sdf.format(smdate));
            bdate = sdf.parse(sdf.format(bdate));
        } catch (ParseException e) {
            e.printStackTrace();
        }
        Calendar cal = Calendar.getInstance();
        cal.setTime(smdate);
        long time1 = cal.getTimeInMillis();
        cal.setTime(bdate);
        long time2 = cal.getTimeInMillis();
        long between_days = (time2 - time1) / (1000 * 3600 * 24);
        return (int) between_days;
    }

    /**
     * 获取指定日后 后 dayAddNum 天的 日期
     *
     * @param day       日期，格式为String："2013-9-3";
     * @param dayAddNum 增加天数 格式为int;
     * @return
     */
    public static String getDateStr(String day, int dayAddNum) {
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
        Date nowDate = null;
        try {
            nowDate = df.parse(day);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        Date newDate2 = new Date(nowDate.getTime() + dayAddNum * 24 * 60 * 60 * 1000);
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        String dateOk = simpleDateFormat.format(newDate2);
        return dateOk;
    }

    /**
     * 字符串转date
     *
     * @param dateStr
     * @param formatStr
     * @return
     */
    public static Date StringToDate(String dateStr, String formatStr) {
        SimpleDateFormat sdf1 = new SimpleDateFormat(formatStr);
        Date date = null;
        try {
            date = sdf1.parse(dateStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }


    /**
     * 匿名评价
     *
     * @param user_name 当前登录名,目前只做手机号、邮箱格式化，用户名暂时不处理
     * @return 打码后的登录名
     */
    public static String Anonymous(String user_name) {
        if (Regular.IsVaildPhoneLength(user_name)) {
            user_name = user_name.replaceAll("(\\d{3})\\d{4}(\\d{4})", "$1****$2");
        } else if (Regular.IsVaildEmail(user_name)) {
            int index = user_name.indexOf("@") - 1;
            int length = index - 1;
            if (length > 0) {
                String rex = "(\\w{1})\\w{" + length + "}(\\w{1})";
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < length; i++) {
                    sb.append("*");
                }
                user_name = user_name.replaceAll(rex, "$1" + sb.toString() + "$2");
            }
        } else {
            // TODO 用户名打码
        }
        return user_name;
    }


    /**
     * 比较时间大小 用来判断速秒杀是否过期
     *
     * @param date1
     * @param date2
     * @return
     */
    public static int compareTotime(String date1, String date2) {
        int result;
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        Calendar c1 = Calendar.getInstance();
        Calendar c2 = Calendar.getInstance();

        try {
            c1.setTime(df.parse(date1));
            c2.setTime(df.parse(date2));
        } catch (ParseException e) {
            System.err.println("格式不正确");
        }
        result = c1.compareTo(c2);
        if (result == 0)
            System.out.println("c1相等c2");

        else if (result < 0)

            System.out.println("c1小于c2");

        else if (result > 0)
            System.out.println("c1大于c2");
        return result;
    }


}
